home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / eiffel / smalleif.97 / se.t / SmallEiffel / bin_c / pretty11.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-02  |  24.4 KB  |  1,085 lines
  1. /* ANSI C code generated by SmallEiffel. */
  2. /*
  3. -- SmallEiffel  -- Release (- 0.97)    --      FRANCE
  4. -- Copyright (C), 1994 - Dominique COLNET and Suzanne COLLIN 
  5. -- University Henri Poincare' - Nancy 1 - email colnet@loria.fr 
  6. -- CRIN (Centre de Recherche en Informatique de Nancy)
  7. -- FRANCE 
  8. */
  9. #include "pretty.h"
  10. void rT42add_last(T42 *C,T0* a1){
  11. /*IF*/if (((C)->_capacity)<((rT42count(C))+(1))) {
  12. C->_capacity=((C)->_capacity)+(16);
  13. /*IF*/if (((C)->_capacity)==(16)) {
  14. C->_storage=malloc(16*sizeof(*(C->_storage)));
  15. }
  16. else {
  17. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  18. }
  19. /*FI*/}
  20. /*FI*/C->_upper=((C)->_upper)+(1);
  21. rT42put(C,a1,(C)->_upper);
  22. }
  23. int rT42equal_like(/*C*/T0* a1,T0* a2){
  24. int R=0;
  25. /*IF*//*AF*/if (((T0 *)a1)==((T0 *)a2)) {
  26. R=1;
  27. }
  28.  else if ((!(a1))||(!(a2))) {
  29. }
  30. else {
  31. R=rT7is_equal((T7*)a1,a2);
  32. }
  33. /*FI*/return R;
  34. }
  35. int rT42index_of(T42 *C,T0* a1){
  36. int R=0;
  37. R=(C)->_lower;
  38. while (!(((R)>((C)->_upper))||(rT42equal_like(a1,rT42item(C,R))))) {
  39. R=(R)+(1);
  40. }
  41. return R;
  42. }
  43. void rT42put(T42 *C,T0* a1,int a2){
  44. (C->_storage)[a2-(C->_lower)]=a1;
  45. }
  46. void rT42copy(T42 *C,T0* a1){
  47. int _i=0;
  48. C->_upper=((C)->_lower)-(1);
  49. /*IF*/if (((C)->_capacity)==(0)) {
  50. rT42make(C,((T42*)a1)->_lower,((T42*)a1)->_upper);
  51. }
  52. else {
  53. rT42resize(C,((T42*)a1)->_lower,((T42*)a1)->_upper);
  54. }
  55. /*FI*/_i=(C)->_lower;
  56. while (!((_i)>((C)->_upper))) {
  57. rT42put(C,rT42item((T42*)a1,_i),_i);
  58. _i=(_i)+(1);
  59. }
  60. }
  61. void rT42make(T42 *C,int a1,int a2){
  62. /*IF*/{/*AT*/free(C->_storage);
  63. }
  64. /*FI*/C->_lower=a1;
  65. C->_upper=a2;
  66. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  67. C->_storage=NULL;
  68. /*IF*/if (((C)->_capacity)>(0)) {
  69. C->_capacity=((C)->_capacity)+(16);
  70. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  71. rT42clear_all(C);
  72. }
  73. /*FI*/}
  74. void rT104clear_all(T104 *C){
  75. T0 * _value=NULL;
  76. rT104set_all_with(C,_value);
  77. }
  78. int rT104count(T104 *C){
  79. int R=0;
  80. R=(((C)->_upper)-((C)->_lower))+(1);
  81. return R;
  82. }
  83. void rT104set_all_with(T104 *C,T0 * a1){
  84. int _i=0;
  85. _i=(C)->_upper;
  86. while (!((_i)<((C)->_lower))) {
  87. rT104put(C,a1,_i);
  88. _i=(_i)-(1);
  89. }
  90. }
  91. void rT104resize(T104 *C,int a1,int a2){
  92. int _up=0;
  93. int _i=0;
  94. T0* _other=NULL;
  95. {T104 *n=((T104*)new(104));
  96. rT104make(n,a1,a2);
  97. _other=(T0 *)n;}
  98. _i=rT2max((C)->_lower,((T104*)_other)->_lower);
  99. _up=rT2min((C)->_upper,((T104*)_other)->_upper);
  100. while (!((_i)>(_up))) {
  101. rT104put((T104*)_other,rT104item(C,_i),_i);
  102. _i=(_i)+(1);
  103. }
  104. /*IF*/{/*AT*/free(C->_storage);
  105. }
  106. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  107. }
  108. T0 * rT104item(T104 *C,int a1){
  109. T0 * R=NULL;
  110. R=(C->_storage)[a1-(C->_lower)];
  111. return R;
  112. }
  113. void rT104add_last(T104 *C,T0 * a1){
  114. /*IF*/if (((C)->_capacity)<((rT104count(C))+(1))) {
  115. C->_capacity=((C)->_capacity)+(16);
  116. /*IF*/if (((C)->_capacity)==(16)) {
  117. C->_storage=malloc(16*sizeof(*(C->_storage)));
  118. }
  119. else {
  120. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  121. }
  122. /*FI*/}
  123. /*FI*/C->_upper=((C)->_upper)+(1);
  124. rT104put(C,a1,(C)->_upper);
  125. }
  126. void rT104put(T104 *C,T0 * a1,int a2){
  127. (C->_storage)[a2-(C->_lower)]=a1;
  128. }
  129. void rT104copy(T104 *C,T0* a1){
  130. int _i=0;
  131. C->_upper=((C)->_lower)-(1);
  132. /*IF*/if (((C)->_capacity)==(0)) {
  133. rT104make(C,((T104*)a1)->_lower,((T104*)a1)->_upper);
  134. }
  135. else {
  136. rT104resize(C,((T104*)a1)->_lower,((T104*)a1)->_upper);
  137. }
  138. /*FI*/_i=(C)->_lower;
  139. while (!((_i)>((C)->_upper))) {
  140. rT104put(C,rT104item((T104*)a1,_i),_i);
  141. _i=(_i)+(1);
  142. }
  143. }
  144. void rT104make(T104 *C,int a1,int a2){
  145. /*IF*/{/*AT*/free(C->_storage);
  146. }
  147. /*FI*/C->_lower=a1;
  148. C->_upper=a2;
  149. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  150. C->_storage=NULL;
  151. /*IF*/if (((C)->_capacity)>(0)) {
  152. C->_capacity=((C)->_capacity)+(16);
  153. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  154. rT104clear_all(C);
  155. }
  156. /*FI*/}
  157. void rT119clear_all(T119 *C){
  158. T0 * _value=NULL;
  159. rT119set_all_with(C,_value);
  160. }
  161. int rT119count(T119 *C){
  162. int R=0;
  163. R=(((C)->_upper)-((C)->_lower))+(1);
  164. return R;
  165. }
  166. void rT119set_all_with(T119 *C,T0 * a1){
  167. int _i=0;
  168. _i=(C)->_upper;
  169. while (!((_i)<((C)->_lower))) {
  170. rT119put(C,a1,_i);
  171. _i=(_i)-(1);
  172. }
  173. }
  174. void rT119resize(T119 *C,int a1,int a2){
  175. int _up=0;
  176. int _i=0;
  177. T0* _other=NULL;
  178. {T119 *n=((T119*)new(119));
  179. rT119make(n,a1,a2);
  180. _other=(T0 *)n;}
  181. _i=rT2max((C)->_lower,((T119*)_other)->_lower);
  182. _up=rT2min((C)->_upper,((T119*)_other)->_upper);
  183. while (!((_i)>(_up))) {
  184. rT119put((T119*)_other,rT119item(C,_i),_i);
  185. _i=(_i)+(1);
  186. }
  187. /*IF*/{/*AT*/free(C->_storage);
  188. }
  189. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  190. }
  191. T0 * rT119item(T119 *C,int a1){
  192. T0 * R=NULL;
  193. R=(C->_storage)[a1-(C->_lower)];
  194. return R;
  195. }
  196. void rT119add_last(T119 *C,T0 * a1){
  197. /*IF*/if (((C)->_capacity)<((rT119count(C))+(1))) {
  198. C->_capacity=((C)->_capacity)+(16);
  199. /*IF*/if (((C)->_capacity)==(16)) {
  200. C->_storage=malloc(16*sizeof(*(C->_storage)));
  201. }
  202. else {
  203. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  204. }
  205. /*FI*/}
  206. /*FI*/C->_upper=((C)->_upper)+(1);
  207. rT119put(C,a1,(C)->_upper);
  208. }
  209. void rT119put(T119 *C,T0 * a1,int a2){
  210. (C->_storage)[a2-(C->_lower)]=a1;
  211. }
  212. void rT119copy(T119 *C,T0* a1){
  213. int _i=0;
  214. C->_upper=((C)->_lower)-(1);
  215. /*IF*/if (((C)->_capacity)==(0)) {
  216. rT119make(C,((T119*)a1)->_lower,((T119*)a1)->_upper);
  217. }
  218. else {
  219. rT119resize(C,((T119*)a1)->_lower,((T119*)a1)->_upper);
  220. }
  221. /*FI*/_i=(C)->_lower;
  222. while (!((_i)>((C)->_upper))) {
  223. rT119put(C,rT119item((T119*)a1,_i),_i);
  224. _i=(_i)+(1);
  225. }
  226. }
  227. void rT119make(T119 *C,int a1,int a2){
  228. /*IF*/{/*AT*/free(C->_storage);
  229. }
  230. /*FI*/C->_lower=a1;
  231. C->_upper=a2;
  232. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  233. C->_storage=NULL;
  234. /*IF*/if (((C)->_capacity)>(0)) {
  235. C->_capacity=((C)->_capacity)+(16);
  236. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  237. rT119clear_all(C);
  238. }
  239. /*FI*/}
  240. void rT123clear_all(T123 *C){
  241. T0 * _value=NULL;
  242. rT123set_all_with(C,_value);
  243. }
  244. int rT123count(T123 *C){
  245. int R=0;
  246. R=(((C)->_upper)-((C)->_lower))+(1);
  247. return R;
  248. }
  249. void rT123set_all_with(T123 *C,T0 * a1){
  250. int _i=0;
  251. _i=(C)->_upper;
  252. while (!((_i)<((C)->_lower))) {
  253. rT123put(C,a1,_i);
  254. _i=(_i)-(1);
  255. }
  256. }
  257. void rT123resize(T123 *C,int a1,int a2){
  258. int _up=0;
  259. int _i=0;
  260. T0* _other=NULL;
  261. {T123 *n=((T123*)new(123));
  262. rT123make(n,a1,a2);
  263. _other=(T0 *)n;}
  264. _i=rT2max((C)->_lower,((T123*)_other)->_lower);
  265. _up=rT2min((C)->_upper,((T123*)_other)->_upper);
  266. while (!((_i)>(_up))) {
  267. rT123put((T123*)_other,rT123item(C,_i),_i);
  268. _i=(_i)+(1);
  269. }
  270. /*IF*/{/*AT*/free(C->_storage);
  271. }
  272. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  273. }
  274. T0 * rT123item(T123 *C,int a1){
  275. T0 * R=NULL;
  276. R=(C->_storage)[a1-(C->_lower)];
  277. return R;
  278. }
  279. void rT123add_last(T123 *C,T0 * a1){
  280. /*IF*/if (((C)->_capacity)<((rT123count(C))+(1))) {
  281. C->_capacity=((C)->_capacity)+(16);
  282. /*IF*/if (((C)->_capacity)==(16)) {
  283. C->_storage=malloc(16*sizeof(*(C->_storage)));
  284. }
  285. else {
  286. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  287. }
  288. /*FI*/}
  289. /*FI*/C->_upper=((C)->_upper)+(1);
  290. rT123put(C,a1,(C)->_upper);
  291. }
  292. void rT123put(T123 *C,T0 * a1,int a2){
  293. (C->_storage)[a2-(C->_lower)]=a1;
  294. }
  295. void rT123copy(T123 *C,T0* a1){
  296. int _i=0;
  297. C->_upper=((C)->_lower)-(1);
  298. /*IF*/if (((C)->_capacity)==(0)) {
  299. rT123make(C,((T123*)a1)->_lower,((T123*)a1)->_upper);
  300. }
  301. else {
  302. rT123resize(C,((T123*)a1)->_lower,((T123*)a1)->_upper);
  303. }
  304. /*FI*/_i=(C)->_lower;
  305. while (!((_i)>((C)->_upper))) {
  306. rT123put(C,rT123item((T123*)a1,_i),_i);
  307. _i=(_i)+(1);
  308. }
  309. }
  310. void rT123make(T123 *C,int a1,int a2){
  311. /*IF*/{/*AT*/free(C->_storage);
  312. }
  313. /*FI*/C->_lower=a1;
  314. C->_upper=a2;
  315. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  316. C->_storage=NULL;
  317. /*IF*/if (((C)->_capacity)>(0)) {
  318. C->_capacity=((C)->_capacity)+(16);
  319. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  320. rT123clear_all(C);
  321. }
  322. /*FI*/}
  323. void rT125clear_all(T125 *C){
  324. T0 * _value=NULL;
  325. rT125set_all_with(C,_value);
  326. }
  327. int rT125count(T125 *C){
  328. int R=0;
  329. R=(((C)->_upper)-((C)->_lower))+(1);
  330. return R;
  331. }
  332. void rT125set_all_with(T125 *C,T0 * a1){
  333. int _i=0;
  334. _i=(C)->_upper;
  335. while (!((_i)<((C)->_lower))) {
  336. rT125put(C,a1,_i);
  337. _i=(_i)-(1);
  338. }
  339. }
  340. void rT125resize(T125 *C,int a1,int a2){
  341. int _up=0;
  342. int _i=0;
  343. T0* _other=NULL;
  344. {T125 *n=((T125*)new(125));
  345. rT125make(n,a1,a2);
  346. _other=(T0 *)n;}
  347. _i=rT2max((C)->_lower,((T125*)_other)->_lower);
  348. _up=rT2min((C)->_upper,((T125*)_other)->_upper);
  349. while (!((_i)>(_up))) {
  350. rT125put((T125*)_other,rT125item(C,_i),_i);
  351. _i=(_i)+(1);
  352. }
  353. /*IF*/{/*AT*/free(C->_storage);
  354. }
  355. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  356. }
  357. T0 * rT125item(T125 *C,int a1){
  358. T0 * R=NULL;
  359. R=(C->_storage)[a1-(C->_lower)];
  360. return R;
  361. }
  362. void rT125add_last(T125 *C,T0 * a1){
  363. /*IF*/if (((C)->_capacity)<((rT125count(C))+(1))) {
  364. C->_capacity=((C)->_capacity)+(16);
  365. /*IF*/if (((C)->_capacity)==(16)) {
  366. C->_storage=malloc(16*sizeof(*(C->_storage)));
  367. }
  368. else {
  369. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  370. }
  371. /*FI*/}
  372. /*FI*/C->_upper=((C)->_upper)+(1);
  373. rT125put(C,a1,(C)->_upper);
  374. }
  375. void rT125put(T125 *C,T0 * a1,int a2){
  376. (C->_storage)[a2-(C->_lower)]=a1;
  377. }
  378. void rT125copy(T125 *C,T0* a1){
  379. int _i=0;
  380. C->_upper=((C)->_lower)-(1);
  381. /*IF*/if (((C)->_capacity)==(0)) {
  382. rT125make(C,((T125*)a1)->_lower,((T125*)a1)->_upper);
  383. }
  384. else {
  385. rT125resize(C,((T125*)a1)->_lower,((T125*)a1)->_upper);
  386. }
  387. /*FI*/_i=(C)->_lower;
  388. while (!((_i)>((C)->_upper))) {
  389. rT125put(C,rT125item((T125*)a1,_i),_i);
  390. _i=(_i)+(1);
  391. }
  392. }
  393. void rT125make(T125 *C,int a1,int a2){
  394. /*IF*/{/*AT*/free(C->_storage);
  395. }
  396. /*FI*/C->_lower=a1;
  397. C->_upper=a2;
  398. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  399. C->_storage=NULL;
  400. /*IF*/if (((C)->_capacity)>(0)) {
  401. C->_capacity=((C)->_capacity)+(16);
  402. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  403. rT125clear_all(C);
  404. }
  405. /*FI*/}
  406. void rT127clear(T127 *C){
  407. C->_upper=((C)->_lower)-(1);
  408. }
  409. void rT127clear_all(T127 *C){
  410. T0 * _value=NULL;
  411. rT127set_all_with(C,_value);
  412. }
  413. T0 * rT127first(T127 *C){
  414. T0 * R=NULL;
  415. R=rT127item(C,(C)->_lower);
  416. return R;
  417. }
  418. int rT127count(T127 *C){
  419. int R=0;
  420. R=(((C)->_upper)-((C)->_lower))+(1);
  421. return R;
  422. }
  423. void rT127set_all_with(T127 *C,T0 * a1){
  424. int _i=0;
  425. _i=(C)->_upper;
  426. while (!((_i)<((C)->_lower))) {
  427. rT127put(C,a1,_i);
  428. _i=(_i)-(1);
  429. }
  430. }
  431. void rT127resize(T127 *C,int a1,int a2){
  432. int _up=0;
  433. int _i=0;
  434. T0* _other=NULL;
  435. {T127 *n=((T127*)new(127));
  436. rT127make(n,a1,a2);
  437. _other=(T0 *)n;}
  438. _i=rT2max((C)->_lower,((T127*)_other)->_lower);
  439. _up=rT2min((C)->_upper,((T127*)_other)->_upper);
  440. while (!((_i)>(_up))) {
  441. rT127put((T127*)_other,rT127item(C,_i),_i);
  442. _i=(_i)+(1);
  443. }
  444. /*IF*/{/*AT*/free(C->_storage);
  445. }
  446. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  447. }
  448. T0 * rT127item(T127 *C,int a1){
  449. T0 * R=NULL;
  450. R=(C->_storage)[a1-(C->_lower)];
  451. return R;
  452. }
  453. void rT127add_last(T127 *C,T0 * a1){
  454. /*IF*/if (((C)->_capacity)<((rT127count(C))+(1))) {
  455. C->_capacity=((C)->_capacity)+(16);
  456. /*IF*/if (((C)->_capacity)==(16)) {
  457. C->_storage=malloc(16*sizeof(*(C->_storage)));
  458. }
  459. else {
  460. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  461. }
  462. /*FI*/}
  463. /*FI*/C->_upper=((C)->_upper)+(1);
  464. rT127put(C,a1,(C)->_upper);
  465. }
  466. void rT127put(T127 *C,T0 * a1,int a2){
  467. (C->_storage)[a2-(C->_lower)]=a1;
  468. }
  469. void rT127copy(T127 *C,T0* a1){
  470. int _i=0;
  471. C->_upper=((C)->_lower)-(1);
  472. /*IF*/if (((C)->_capacity)==(0)) {
  473. rT127make(C,((T127*)a1)->_lower,((T127*)a1)->_upper);
  474. }
  475. else {
  476. rT127resize(C,((T127*)a1)->_lower,((T127*)a1)->_upper);
  477. }
  478. /*FI*/_i=(C)->_lower;
  479. while (!((_i)>((C)->_upper))) {
  480. rT127put(C,rT127item((T127*)a1,_i),_i);
  481. _i=(_i)+(1);
  482. }
  483. }
  484. void rT127make(T127 *C,int a1,int a2){
  485. /*IF*/{/*AT*/free(C->_storage);
  486. }
  487. /*FI*/C->_lower=a1;
  488. C->_upper=a2;
  489. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  490. C->_storage=NULL;
  491. /*IF*/if (((C)->_capacity)>(0)) {
  492. C->_capacity=((C)->_capacity)+(16);
  493. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  494. rT127clear_all(C);
  495. }
  496. /*FI*/}
  497. void rT128clear_all(T128 *C){
  498. T0 * _value=NULL;
  499. rT128set_all_with(C,_value);
  500. }
  501. int rT128count(T128 *C){
  502. int R=0;
  503. R=(((C)->_upper)-((C)->_lower))+(1);
  504. return R;
  505. }
  506. void rT128set_all_with(T128 *C,T0 * a1){
  507. int _i=0;
  508. _i=(C)->_upper;
  509. while (!((_i)<((C)->_lower))) {
  510. rT128put(C,a1,_i);
  511. _i=(_i)-(1);
  512. }
  513. }
  514. void rT128resize(T128 *C,int a1,int a2){
  515. int _up=0;
  516. int _i=0;
  517. T0* _other=NULL;
  518. {T128 *n=((T128*)new(128));
  519. rT128make(n,a1,a2);
  520. _other=(T0 *)n;}
  521. _i=rT2max((C)->_lower,((T128*)_other)->_lower);
  522. _up=rT2min((C)->_upper,((T128*)_other)->_upper);
  523. while (!((_i)>(_up))) {
  524. rT128put((T128*)_other,rT128item(C,_i),_i);
  525. _i=(_i)+(1);
  526. }
  527. /*IF*/{/*AT*/free(C->_storage);
  528. }
  529. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  530. }
  531. T0 * rT128item(T128 *C,int a1){
  532. T0 * R=NULL;
  533. R=(C->_storage)[a1-(C->_lower)];
  534. return R;
  535. }
  536. void rT128add_last(T128 *C,T0 * a1){
  537. /*IF*/if (((C)->_capacity)<((rT128count(C))+(1))) {
  538. C->_capacity=((C)->_capacity)+(16);
  539. /*IF*/if (((C)->_capacity)==(16)) {
  540. C->_storage=malloc(16*sizeof(*(C->_storage)));
  541. }
  542. else {
  543. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  544. }
  545. /*FI*/}
  546. /*FI*/C->_upper=((C)->_upper)+(1);
  547. rT128put(C,a1,(C)->_upper);
  548. }
  549. void rT128put(T128 *C,T0 * a1,int a2){
  550. (C->_storage)[a2-(C->_lower)]=a1;
  551. }
  552. void rT128copy(T128 *C,T0* a1){
  553. int _i=0;
  554. C->_upper=((C)->_lower)-(1);
  555. /*IF*/if (((C)->_capacity)==(0)) {
  556. rT128make(C,((T128*)a1)->_lower,((T128*)a1)->_upper);
  557. }
  558. else {
  559. rT128resize(C,((T128*)a1)->_lower,((T128*)a1)->_upper);
  560. }
  561. /*FI*/_i=(C)->_lower;
  562. while (!((_i)>((C)->_upper))) {
  563. rT128put(C,rT128item((T128*)a1,_i),_i);
  564. _i=(_i)+(1);
  565. }
  566. }
  567. void rT128make(T128 *C,int a1,int a2){
  568. /*IF*/{/*AT*/free(C->_storage);
  569. }
  570. /*FI*/C->_lower=a1;
  571. C->_upper=a2;
  572. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  573. C->_storage=NULL;
  574. /*IF*/if (((C)->_capacity)>(0)) {
  575. C->_capacity=((C)->_capacity)+(16);
  576. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  577. rT128clear_all(C);
  578. }
  579. /*FI*/}
  580. void rT132clear_all(T132 *C){
  581. T0 * _value=NULL;
  582. rT132set_all_with(C,_value);
  583. }
  584. int rT132count(T132 *C){
  585. int R=0;
  586. R=(((C)->_upper)-((C)->_lower))+(1);
  587. return R;
  588. }
  589. void rT132set_all_with(T132 *C,T0 * a1){
  590. int _i=0;
  591. _i=(C)->_upper;
  592. while (!((_i)<((C)->_lower))) {
  593. rT132put(C,a1,_i);
  594. _i=(_i)-(1);
  595. }
  596. }
  597. void rT132resize(T132 *C,int a1,int a2){
  598. int _up=0;
  599. int _i=0;
  600. T0* _other=NULL;
  601. {T132 *n=((T132*)new(132));
  602. rT132make(n,a1,a2);
  603. _other=(T0 *)n;}
  604. _i=rT2max((C)->_lower,((T132*)_other)->_lower);
  605. _up=rT2min((C)->_upper,((T132*)_other)->_upper);
  606. while (!((_i)>(_up))) {
  607. rT132put((T132*)_other,rT132item(C,_i),_i);
  608. _i=(_i)+(1);
  609. }
  610. /*IF*/{/*AT*/free(C->_storage);
  611. }
  612. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  613. }
  614. T0 * rT132item(T132 *C,int a1){
  615. T0 * R=NULL;
  616. R=(C->_storage)[a1-(C->_lower)];
  617. return R;
  618. }
  619. void rT132add_last(T132 *C,T0 * a1){
  620. /*IF*/if (((C)->_capacity)<((rT132count(C))+(1))) {
  621. C->_capacity=((C)->_capacity)+(16);
  622. /*IF*/if (((C)->_capacity)==(16)) {
  623. C->_storage=malloc(16*sizeof(*(C->_storage)));
  624. }
  625. else {
  626. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  627. }
  628. /*FI*/}
  629. /*FI*/C->_upper=((C)->_upper)+(1);
  630. rT132put(C,a1,(C)->_upper);
  631. }
  632. void rT132put(T132 *C,T0 * a1,int a2){
  633. (C->_storage)[a2-(C->_lower)]=a1;
  634. }
  635. void rT132copy(T132 *C,T0* a1){
  636. int _i=0;
  637. C->_upper=((C)->_lower)-(1);
  638. /*IF*/if (((C)->_capacity)==(0)) {
  639. rT132make(C,((T132*)a1)->_lower,((T132*)a1)->_upper);
  640. }
  641. else {
  642. rT132resize(C,((T132*)a1)->_lower,((T132*)a1)->_upper);
  643. }
  644. /*FI*/_i=(C)->_lower;
  645. while (!((_i)>((C)->_upper))) {
  646. rT132put(C,rT132item((T132*)a1,_i),_i);
  647. _i=(_i)+(1);
  648. }
  649. }
  650. void rT132make(T132 *C,int a1,int a2){
  651. /*IF*/{/*AT*/free(C->_storage);
  652. }
  653. /*FI*/C->_lower=a1;
  654. C->_upper=a2;
  655. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  656. C->_storage=NULL;
  657. /*IF*/if (((C)->_capacity)>(0)) {
  658. C->_capacity=((C)->_capacity)+(16);
  659. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  660. rT132clear_all(C);
  661. }
  662. /*FI*/}
  663. void rT139clear_all(T139 *C){
  664. T0 * _value=NULL;
  665. rT139set_all_with(C,_value);
  666. }
  667. int rT139count(T139 *C){
  668. int R=0;
  669. R=(((C)->_upper)-((C)->_lower))+(1);
  670. return R;
  671. }
  672. void rT139set_all_with(T139 *C,T0 * a1){
  673. int _i=0;
  674. _i=(C)->_upper;
  675. while (!((_i)<((C)->_lower))) {
  676. rT139put(C,a1,_i);
  677. _i=(_i)-(1);
  678. }
  679. }
  680. void rT139resize(T139 *C,int a1,int a2){
  681. int _up=0;
  682. int _i=0;
  683. T0* _other=NULL;
  684. {T139 *n=((T139*)new(139));
  685. rT139make(n,a1,a2);
  686. _other=(T0 *)n;}
  687. _i=rT2max((C)->_lower,((T139*)_other)->_lower);
  688. _up=rT2min((C)->_upper,((T139*)_other)->_upper);
  689. while (!((_i)>(_up))) {
  690. rT139put((T139*)_other,rT139item(C,_i),_i);
  691. _i=(_i)+(1);
  692. }
  693. /*IF*/{/*AT*/free(C->_storage);
  694. }
  695. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  696. }
  697. T0 * rT139item(T139 *C,int a1){
  698. T0 * R=NULL;
  699. R=(C->_storage)[a1-(C->_lower)];
  700. return R;
  701. }
  702. void rT139add_last(T139 *C,T0 * a1){
  703. /*IF*/if (((C)->_capacity)<((rT139count(C))+(1))) {
  704. C->_capacity=((C)->_capacity)+(16);
  705. /*IF*/if (((C)->_capacity)==(16)) {
  706. C->_storage=malloc(16*sizeof(*(C->_storage)));
  707. }
  708. else {
  709. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  710. }
  711. /*FI*/}
  712. /*FI*/C->_upper=((C)->_upper)+(1);
  713. rT139put(C,a1,(C)->_upper);
  714. }
  715. void rT139put(T139 *C,T0 * a1,int a2){
  716. (C->_storage)[a2-(C->_lower)]=a1;
  717. }
  718. void rT139copy(T139 *C,T0* a1){
  719. int _i=0;
  720. C->_upper=((C)->_lower)-(1);
  721. /*IF*/if (((C)->_capacity)==(0)) {
  722. rT139make(C,((T139*)a1)->_lower,((T139*)a1)->_upper);
  723. }
  724. else {
  725. rT139resize(C,((T139*)a1)->_lower,((T139*)a1)->_upper);
  726. }
  727. /*FI*/_i=(C)->_lower;
  728. while (!((_i)>((C)->_upper))) {
  729. rT139put(C,rT139item((T139*)a1,_i),_i);
  730. _i=(_i)+(1);
  731. }
  732. }
  733. void rT139make(T139 *C,int a1,int a2){
  734. /*IF*/{/*AT*/free(C->_storage);
  735. }
  736. /*FI*/C->_lower=a1;
  737. C->_upper=a2;
  738. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  739. C->_storage=NULL;
  740. /*IF*/if (((C)->_capacity)>(0)) {
  741. C->_capacity=((C)->_capacity)+(16);
  742. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  743. rT139clear_all(C);
  744. }
  745. /*FI*/}
  746. void rT141clear_all(T141 *C){
  747. T0 * _value=NULL;
  748. rT141set_all_with(C,_value);
  749. }
  750. T0 * rT141first(T141 *C){
  751. T0 * R=NULL;
  752. R=rT141item(C,(C)->_lower);
  753. return R;
  754. }
  755. int rT141count(T141 *C){
  756. int R=0;
  757. R=(((C)->_upper)-((C)->_lower))+(1);
  758. return R;
  759. }
  760. void rT141set_all_with(T141 *C,T0 * a1){
  761. int _i=0;
  762. _i=(C)->_upper;
  763. while (!((_i)<((C)->_lower))) {
  764. rT141put(C,a1,_i);
  765. _i=(_i)-(1);
  766. }
  767. }
  768. void rT141resize(T141 *C,int a1,int a2){
  769. int _up=0;
  770. int _i=0;
  771. T0* _other=NULL;
  772. {T141 *n=((T141*)new(141));
  773. rT141make(n,a1,a2);
  774. _other=(T0 *)n;}
  775. _i=rT2max((C)->_lower,XrT141lower(_other));
  776. _up=rT2min((C)->_upper,XrT141upper(_other));
  777. while (!((_i)>(_up))) {
  778. XrT141put(_other,rT141item(C,_i),_i);
  779. _i=(_i)+(1);
  780. }
  781. /*IF*/{/*AT*/free(C->_storage);
  782. }
  783. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  784. }
  785. T0 * rT141item(T141 *C,int a1){
  786. T0 * R=NULL;
  787. R=(C->_storage)[a1-(C->_lower)];
  788. return R;
  789. }
  790. void rT141add_last(T141 *C,T0 * a1){
  791. /*IF*/if (((C)->_capacity)<((rT141count(C))+(1))) {
  792. C->_capacity=((C)->_capacity)+(16);
  793. /*IF*/if (((C)->_capacity)==(16)) {
  794. C->_storage=malloc(16*sizeof(*(C->_storage)));
  795. }
  796. else {
  797. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  798. }
  799. /*FI*/}
  800. /*FI*/C->_upper=((C)->_upper)+(1);
  801. rT141put(C,a1,(C)->_upper);
  802. }
  803. void rT141put(T141 *C,T0 * a1,int a2){
  804. (C->_storage)[a2-(C->_lower)]=a1;
  805. }
  806. void rT141copy(T141 *C,T0* a1){
  807. int _i=0;
  808. C->_upper=((C)->_lower)-(1);
  809. /*IF*/if (((C)->_capacity)==(0)) {
  810. rT141make(C,XrT141lower(a1),XrT141upper(a1));
  811. }
  812. else {
  813. rT141resize(C,XrT141lower(a1),XrT141upper(a1));
  814. }
  815. /*FI*/_i=(C)->_lower;
  816. while (!((_i)>((C)->_upper))) {
  817. rT141put(C,XrT141item(a1,_i),_i);
  818. _i=(_i)+(1);
  819. }
  820. }
  821. void rT141make(T141 *C,int a1,int a2){
  822. /*IF*/{/*AT*/free(C->_storage);
  823. }
  824. /*FI*/C->_lower=a1;
  825. C->_upper=a2;
  826. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  827. C->_storage=NULL;
  828. /*IF*/if (((C)->_capacity)>(0)) {
  829. C->_capacity=((C)->_capacity)+(16);
  830. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  831. rT141clear_all(C);
  832. }
  833. /*FI*/}
  834. void rT145clear_all(T145 *C){
  835. T0 * _value=NULL;
  836. rT145set_all_with(C,_value);
  837. }
  838. int rT145count(T145 *C){
  839. int R=0;
  840. R=(((C)->_upper)-((C)->_lower))+(1);
  841. return R;
  842. }
  843. void rT145set_all_with(T145 *C,T0 * a1){
  844. int _i=0;
  845. _i=(C)->_upper;
  846. while (!((_i)<((C)->_lower))) {
  847. rT145put(C,a1,_i);
  848. _i=(_i)-(1);
  849. }
  850. }
  851. void rT145resize(T145 *C,int a1,int a2){
  852. int _up=0;
  853. int _i=0;
  854. T0* _other=NULL;
  855. {T145 *n=((T145*)new(145));
  856. rT145make(n,a1,a2);
  857. _other=(T0 *)n;}
  858. _i=rT2max((C)->_lower,((T145*)_other)->_lower);
  859. _up=rT2min((C)->_upper,((T145*)_other)->_upper);
  860. while (!((_i)>(_up))) {
  861. rT145put((T145*)_other,rT145item(C,_i),_i);
  862. _i=(_i)+(1);
  863. }
  864. /*IF*/{/*AT*/free(C->_storage);
  865. }
  866. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  867. }
  868. T0 * rT145item(T145 *C,int a1){
  869. T0 * R=NULL;
  870. R=(C->_storage)[a1-(C->_lower)];
  871. return R;
  872. }
  873. void rT145add_last(T145 *C,T0 * a1){
  874. /*IF*/if (((C)->_capacity)<((rT145count(C))+(1))) {
  875. C->_capacity=((C)->_capacity)+(16);
  876. /*IF*/if (((C)->_capacity)==(16)) {
  877. C->_storage=malloc(16*sizeof(*(C->_storage)));
  878. }
  879. else {
  880. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  881. }
  882. /*FI*/}
  883. /*FI*/C->_upper=((C)->_upper)+(1);
  884. rT145put(C,a1,(C)->_upper);
  885. }
  886. void rT145put(T145 *C,T0 * a1,int a2){
  887. (C->_storage)[a2-(C->_lower)]=a1;
  888. }
  889. void rT145copy(T145 *C,T0* a1){
  890. int _i=0;
  891. C->_upper=((C)->_lower)-(1);
  892. /*IF*/if (((C)->_capacity)==(0)) {
  893. rT145make(C,((T145*)a1)->_lower,((T145*)a1)->_upper);
  894. }
  895. else {
  896. rT145resize(C,((T145*)a1)->_lower,((T145*)a1)->_upper);
  897. }
  898. /*FI*/_i=(C)->_lower;
  899. while (!((_i)>((C)->_upper))) {
  900. rT145put(C,rT145item((T145*)a1,_i),_i);
  901. _i=(_i)+(1);
  902. }
  903. }
  904. void rT145make(T145 *C,int a1,int a2){
  905. /*IF*/{/*AT*/free(C->_storage);
  906. }
  907. /*FI*/C->_lower=a1;
  908. C->_upper=a2;
  909. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  910. C->_storage=NULL;
  911. /*IF*/if (((C)->_capacity)>(0)) {
  912. C->_capacity=((C)->_capacity)+(16);
  913. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  914. rT145clear_all(C);
  915. }
  916. /*FI*/}
  917. void rT149clear_all(T149 *C){
  918. T0 * _value=NULL;
  919. rT149set_all_with(C,_value);
  920. }
  921. int rT149count(T149 *C){
  922. int R=0;
  923. R=(((C)->_upper)-((C)->_lower))+(1);
  924. return R;
  925. }
  926. void rT149set_all_with(T149 *C,T0 * a1){
  927. int _i=0;
  928. _i=(C)->_upper;
  929. while (!((_i)<((C)->_lower))) {
  930. rT149put(C,a1,_i);
  931. _i=(_i)-(1);
  932. }
  933. }
  934. void rT149resize(T149 *C,int a1,int a2){
  935. int _up=0;
  936. int _i=0;
  937. T0* _other=NULL;
  938. {T149 *n=((T149*)new(149));
  939. rT149make(n,a1,a2);
  940. _other=(T0 *)n;}
  941. _i=rT2max((C)->_lower,((T149*)_other)->_lower);
  942. _up=rT2min((C)->_upper,((T149*)_other)->_upper);
  943. while (!((_i)>(_up))) {
  944. rT149put((T149*)_other,rT149item(C,_i),_i);
  945. _i=(_i)+(1);
  946. }
  947. /*IF*/{/*AT*/free(C->_storage);
  948. }
  949. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  950. }
  951. T0 * rT149item(T149 *C,int a1){
  952. T0 * R=NULL;
  953. R=(C->_storage)[a1-(C->_lower)];
  954. return R;
  955. }
  956. void rT149add_last(T149 *C,T0 * a1){
  957. /*IF*/if (((C)->_capacity)<((rT149count(C))+(1))) {
  958. C->_capacity=((C)->_capacity)+(16);
  959. /*IF*/if (((C)->_capacity)==(16)) {
  960. C->_storage=malloc(16*sizeof(*(C->_storage)));
  961. }
  962. else {
  963. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  964. }
  965. /*FI*/}
  966. /*FI*/C->_upper=((C)->_upper)+(1);
  967. rT149put(C,a1,(C)->_upper);
  968. }
  969. void rT149put(T149 *C,T0 * a1,int a2){
  970. (C->_storage)[a2-(C->_lower)]=a1;
  971. }
  972. void rT149copy(T149 *C,T0* a1){
  973. int _i=0;
  974. C->_upper=((C)->_lower)-(1);
  975. /*IF*/if (((C)->_capacity)==(0)) {
  976. rT149make(C,((T149*)a1)->_lower,((T149*)a1)->_upper);
  977. }
  978. else {
  979. rT149resize(C,((T149*)a1)->_lower,((T149*)a1)->_upper);
  980. }
  981. /*FI*/_i=(C)->_lower;
  982. while (!((_i)>((C)->_upper))) {
  983. rT149put(C,rT149item((T149*)a1,_i),_i);
  984. _i=(_i)+(1);
  985. }
  986. }
  987. void rT149make(T149 *C,int a1,int a2){
  988. /*IF*/{/*AT*/free(C->_storage);
  989. }
  990. /*FI*/C->_lower=a1;
  991. C->_upper=a2;
  992. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  993. C->_storage=NULL;
  994. /*IF*/if (((C)->_capacity)>(0)) {
  995. C->_capacity=((C)->_capacity)+(16);
  996. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  997. rT149clear_all(C);
  998. }
  999. /*FI*/}
  1000. void rT156clear_all(T156 *C){
  1001. T0 * _value=NULL;
  1002. rT156set_all_with(C,_value);
  1003. }
  1004. int rT156count(T156 *C){
  1005. int R=0;
  1006. R=(((C)->_upper)-((C)->_lower))+(1);
  1007. return R;
  1008. }
  1009. void rT156set_all_with(T156 *C,T0 * a1){
  1010. int _i=0;
  1011. _i=(C)->_upper;
  1012. while (!((_i)<((C)->_lower))) {
  1013. rT156put(C,a1,_i);
  1014. _i=(_i)-(1);
  1015. }
  1016. }
  1017. void rT156resize(T156 *C,int a1,int a2){
  1018. int _up=0;
  1019. int _i=0;
  1020. T0* _other=NULL;
  1021. {T156 *n=((T156*)new(156));
  1022. rT156make(n,a1,a2);
  1023. _other=(T0 *)n;}
  1024. _i=rT2max((C)->_lower,((T156*)_other)->_lower);
  1025. _up=rT2min((C)->_upper,((T156*)_other)->_upper);
  1026. while (!((_i)>(_up))) {
  1027. rT156put((T156*)_other,rT156item(C,_i),_i);
  1028. _i=(_i)+(1);
  1029. }
  1030. /*IF*/{/*AT*/free(C->_storage);
  1031. }
  1032. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  1033. }
  1034. T0 * rT156item(T156 *C,int a1){
  1035. T0 * R=NULL;
  1036. R=(C->_storage)[a1-(C->_lower)];
  1037. return R;
  1038. }
  1039. void rT156add_last(T156 *C,T0 * a1){
  1040. /*IF*/if (((C)->_capacity)<((rT156count(C))+(1))) {
  1041. C->_capacity=((C)->_capacity)+(16);
  1042. /*IF*/if (((C)->_capacity)==(16)) {
  1043. C->_storage=malloc(16*sizeof(*(C->_storage)));
  1044. }
  1045. else {
  1046. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  1047. }
  1048. /*FI*/}
  1049. /*FI*/C->_upper=((C)->_upper)+(1);
  1050. rT156put(C,a1,(C)->_upper);
  1051. }
  1052. void rT156put(T156 *C,T0 * a1,int a2){
  1053. (C->_storage)[a2-(C->_lower)]=a1;
  1054. }
  1055. void rT156copy(T156 *C,T0* a1){
  1056. int _i=0;
  1057. C->_upper=((C)->_lower)-(1);
  1058. /*IF*/if (((C)->_capacity)==(0)) {
  1059. rT156make(C,((T156*)a1)->_lower,((T156*)a1)->_upper);
  1060. }
  1061. else {
  1062. rT156resize(C,((T156*)a1)->_lower,((T156*)a1)->_upper);
  1063. }
  1064. /*FI*/_i=(C)->_lower;
  1065. while (!((_i)>((C)->_upper))) {
  1066. rT156put(C,rT156item((T156*)a1,_i),_i);
  1067. _i=(_i)+(1);
  1068. }
  1069. }
  1070. void rT156make(T156 *C,int a1,int a2){
  1071. /*IF*/{/*AT*/free(C->_storage);
  1072. }
  1073. /*FI*/C->_lower=a1;
  1074. C->_upper=a2;
  1075. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  1076. C->_storage=NULL;
  1077. /*IF*/if (((C)->_capacity)>(0)) {
  1078. C->_capacity=((C)->_capacity)+(16);
  1079. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  1080. rT156clear_all(C);
  1081. }
  1082. /*FI*/}
  1083. int argument_count;
  1084. T0 **argument;
  1085.